﻿using System;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Json;
using Caliburn.Micro;
using Microsoft.Phone.Net.NetworkInformation;
using Newtonsoft.Json;
using RestSharp;
using RestSharp.Authenticators;
using WPCloudPT.Eventos;
using WPCloudPT.Model;
using System.IO.IsolatedStorage;
using WPCloudPT.Service;

namespace WPCloudPT.Utils
{
    /// <summary>
    /// classe singleton para invocar e lidar com os resultados das chamadas remotas
    /// </summary>
    public class Utilities
    {
        #region ClassVars
        /// <summary>
        /// variaveis de classe
        /// </summary>
        private static Utilities _instance;
        private static RestClient _client;
        private static RestRequest _request;
        public Utilizador TmpUser { get; set; }
        private static readonly CloudPtDataService DataService = CloudPtDataService.GetInstance();
        public BindableCollection<InformacaoPastas> TmpDadosPastas;
         
        private IsolatedStorageFile TmpIsolatedStrage { get; set; }


        #endregion

        #region Ctor
        /// <summary>
        /// construtor default
        /// </summary>
        private Utilities()
        {

        }

        /// <summary>
        /// metodo para tornar a classe sigleton
        /// </summary>
        /// <returns></returns>
        public static Utilities GetInstance()
        {
            lock (typeof(Utilities))
            {
                return _instance ?? (_instance = new Utilities());
            }
        }
        #endregion



        #region CloudPtLogin
        /// <summary>
        /// Metodo para efectuar o request token
        /// </summary>
        public void CloudPtOauth()
        {

            _client = new RestClient(CloudPtUrls.CloudPtUrl)
                          {
                              Authenticator =
                                  OAuth1Authenticator.ForRequestToken(CloudPtUrls.CloudPtConsumerKey,
                                                                      CloudPtUrls.CloudPtConsumerSecret, "oob")
                          };
            _request = new RestRequest(CloudPtUrls.RequestTokenUrl, Method.GET);

            _client.ExecuteAsync(_request, serverResponse =>
                                               {
                                                   if (serverResponse.ResponseStatus == ResponseStatus.Completed)
                                                   {
                                                       var x = GetQueryParam(serverResponse.Content, "oauth_token");
                                                       if ((x == "Could not verify OAuth request.") || (x == ""))
                                                       {
                                                           EventAggregationProvider.Aggregator.Publish(new EventoUtilizador(TipoEventoUtilizador.TokenError, "Erro ao obter o token"));
                                                       }

                                                       if(TmpUser==null)
                                                       {
                                                           TmpUser= new Utilizador();
                                                       }
                                                     
                                                       var tempUser = new Utilizador
                                                                           {
                                                                               OauthToken = x,
                                                                               OauthTokenSecret =
                                                                                   GetQueryParam(
                                                                                       serverResponse.Content,
                                                                                       "oauth_token_secret")

                                                                           };
                                                       EventAggregationProvider.Aggregator.Publish(new EventoUtilizador(TipoEventoUtilizador.TokenOk, null, tempUser));

                                                   }
                                                   else if (serverResponse.ResponseStatus == ResponseStatus.Error)
                                                   {
                                                       ErrorHandler(serverResponse.Content);
                                                   }
                                               });

        }


        /// <summary>
        /// metodo para efectuar a autorizacao da aplicacao
        /// </summary>
        /// <param name="valueconsumerKey"></param>
        /// <param name="valueconsumerSecret"></param>
        /// <param name="valuetoken"></param>
        /// <param name="valuetokensecret"></param>
        /// <param name="valueverifier"></param>
        public void AuthorizeApp(string valueconsumerKey, string valueconsumerSecret, string valuetoken, string valuetokensecret, string valueverifier)
        {
            _client = new RestClient(CloudPtUrls.CloudPtUrl)
                          {
                              Authenticator =
                                  OAuth1Authenticator.ForAccessToken(valueconsumerKey, valueconsumerSecret, valuetoken,
                                                                     valuetokensecret, valueverifier)
                          };

            _request = new RestRequest(CloudPtUrls.AccessTokenUrl, Method.POST);
            _client.ExecuteAsync(_request, serverResponse =>
            {
                if (serverResponse.ResponseStatus == ResponseStatus.Completed)
                {
                    var x = GetQueryParam(serverResponse.Content, "oauth_token");
                    if ((x == "Could not verify OAuth request.") || (x == ""))
                    {
                        EventAggregationProvider.Aggregator.Publish(new EventoUtilizador(TipoEventoUtilizador.AuthorizationOk, "Erro ao autorizar a aplicacao"));
                    }
                    var tempUser = new Utilizador
                    {
                        OauthToken = x,
                        OauthTokenSecret =
                            GetQueryParam(
                                serverResponse.Content,
                                "oauth_token_secret")

                    };
                    EventAggregationProvider.Aggregator.Publish(new EventoUtilizador(TipoEventoUtilizador.AuthorizationOk, null, tempUser));

                }
                else if (serverResponse.ResponseStatus == ResponseStatus.Error)
                {
                    ErrorHandler(serverResponse.Content);
                }
            });
        }

        #region TokenErrorHandler
        /// <summary>
        /// metodo para lidar com o erro da funcao
        /// </summary>
        /// <param name="val"></param>
        private void ErrorHandler(string val)
        {

            EventAggregationProvider.Aggregator.Publish(new EventoUtilizador(TipoEventoUtilizador.TokenError, val));
        }
        #endregion


        #region GetRequestParam
        /// <summary>
        /// metodo para obter os dados do token
        /// </summary>
        /// <param name="valueInput"></param>
        /// <param name="valueParam"></param>
        /// <returns></returns>
        private static string GetQueryParam(string valueInput, string valueParam)
        {
            foreach (var item in valueInput.Split('&'))
            {
                var parts = item.Split('=');
                if (parts[0] == valueParam)
                {
                    return parts[1];
                }
            }
            return string.Empty;
        }
        #endregion
        #endregion

        #region MetodosCloudPt

        #region DevolveDadosUtilizador
        /// <summary>
        /// metodo para devolver os dados do utilizador
        /// </summary>
        /// <param name="valueToken"></param>
        /// <param name="valueTokenSecret"></param>
        public void DevolveDadosUtilizador(string valueToken, string valueTokenSecret)
        {
            _client = new RestClient(CloudPtUrls.CloudPtApiUrl)
                          {
                              
                              Authenticator = OAuth1Authenticator.ForAccessToken(CloudPtUrls.CloudPtConsumerKey, CloudPtUrls.CloudPtConsumerSecret, valueToken, valueTokenSecret)
                          };


            _request = new RestRequest(CloudPtUrls.CloudPtAccountInfoUrl, Method.GET)
                           {
                               OnBeforeDeserialization = resp => { resp.ContentType = "application/json"; }
                           };
            //_request.AddHeader("Content-type", "application/json; charset=utf-8");
            //_client.AddHandler("text/plain", new JsonDeserializer());
            _client.Timeout = 120000;
            _request.RequestFormat = DataFormat.Json;


            _client.ExecuteAsync(_request, clientResponse =>
                                                                  {
                                                                      if (clientResponse.ResponseStatus == ResponseStatus.Completed)
                                                                      {

                                                                          ValidationHandler(clientResponse.Content);
                                                                      }
                                                                      if ((clientResponse.ResponseStatus == ResponseStatus.None) || (clientResponse.ResponseStatus == ResponseStatus.Error))
                                                                      {
                                                                          ErrorHandler(clientResponse.ErrorException.Message);
                                                                      }
                                                                  });
        }

        /// <summary>
        /// metodo para deserializar os conteudos devolvidos
        /// </summary>
        /// <param name="content"></param>
        private static void ValidationHandler(string content)
        {
            //var serializer = new JsonSerializer();
            //serializer.Converters.Add(new UtilizadorConverter());
            ////var tmp = JsonConvert.DeserializeObject<Utilizador>(content);
            //var tmp = serializer.Deserialize(new StringReader(content), typeof (Utilizador));

            try
            {
                using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(content)))
                {
                    var ser = new DataContractJsonSerializer(typeof(Utilizador));
                    var tmp = (Utilizador)ser.ReadObject(ms);


                    
                    EventAggregationProvider.Aggregator.Publish(new EventoUtilizador(TipoEventoUtilizador.InfoUserOk, null, tmp));
                }
            }
            catch (Exception e)
            {
                EventAggregationProvider.Aggregator.Publish(e.InnerException == null
                                                                ? new AppMessage(AppMessageType.Erro, e.Message)
                                                                : new AppMessage(AppMessageType.Erro,
                                                                                 e.InnerException + "\n" +
                                                                                 e.Message));
            }
           
        }
        public void InjectaDadosUtilizador(Utilizador value)
        {
            DataService.InjectUser(value);
        }

        public Utilizador ObtemInformacaoUtilizador()
        {
           TmpUser= DataService.ReturnUserData();
           return TmpUser;
        }
        #endregion

        #region DevolveDadosMetadata
        public void DevolveDadosMetadata()
        {

        }

        #region DevolveDadosMetadataShare
        public void DevolveMetadataShare()
        {

        }
        #endregion
        #endregion


        #region LinksUtilizador
        #region DevolveLinksUtilizador
        public void DevolveLinksUtilizador()
        {

        }
        #endregion
        #region DeleteLink
        #endregion
        #region CreateLink
        #endregion

        #endregion

        #region ShareFolder
        #region CreateSharedFolder
        #endregion
        #region ListSharedFolders

        #endregion

        #endregion

        #region ListaDados
        
        #region DevolveListaDadosFicheiro

        /// <summary>
        /// metodo para obter a lista de ficheiros do servidor(aponta para sandbox
        /// </summary>
        public void DevolveListaFicheiro()
        {
            _client = new RestClient(CloudPtUrls.CloudPtApiUrl)
                          {
                              Authenticator =
                                  OAuth1Authenticator.ForAccessToken(CloudPtUrls.CloudPtConsumerKey,
                                                                     CloudPtUrls.CloudPtConsumerSecret, TmpUser.OauthToken,
                                                                     TmpUser.OauthTokenSecret)
                          };

            _request = new RestRequest(CloudPtUrls.CloudPtGetConteudoUrl, Method.GET)
                           {
                               OnBeforeDeserialization = resp => { resp.ContentType = "application/json"; }
                           };
            _request.AddParameter("order_ascending", true, ParameterType.UrlSegment);
            _request.AddParameter("include_deleted", false, ParameterType.UrlSegment);

            _client.Timeout = 120000;
            _request.RequestFormat = DataFormat.Json;
            _client.ExecuteAsync(_request, clientResponse =>
                                               {
                                                   if(clientResponse.ResponseStatus==ResponseStatus.Completed)
                                                   {
                                                       ContentvalidationHandler(clientResponse.Content);
                                                   }
                                                   if((clientResponse.ResponseStatus==ResponseStatus.None)||(clientResponse.ResponseStatus == ResponseStatus.Error))
                                                   {
                                                       ErrorHandler(clientResponse.ErrorException.Message);
                                                   }
                                               });
        }


        /// <summary>
        /// metodo para deserializar os dados devolvidos do servidor
        /// </summary>
        /// <param name="value"></param>
        private  void ContentvalidationHandler(string value)
        {
            try
            {
                var tmp = JsonConvert.DeserializeObject<InformacaoPastas>(value);
                
                
                    TmpDadosPastas = new BindableCollection<InformacaoPastas> {tmp};

                EventAggregationProvider.Aggregator.Publish(new EventoUtilizador(TipoEventoUtilizador.ConteudoUserOk));
              
            }
            catch (Exception e)
            {

                EventAggregationProvider.Aggregator.Publish(e.InnerException == null
                                                                ? new AppMessage(AppMessageType.Erro, e.Message)
                                                                : new AppMessage(AppMessageType.Erro,
                                                                                 e.InnerException + "\n" +
                                                                                 e.Message));
            }
        }

       

        #endregion


        #endregion


        

        #region SearchFiles
        public void PesquisaConteudo(string value)
        {
            _client = new RestClient(CloudPtUrls.CloudPtApiUrl)
                          {
                              Authenticator =
                                  OAuth1Authenticator.ForAccessToken(CloudPtUrls.CloudPtConsumerKey,
                                                                     CloudPtUrls.CloudPtConsumerSecret,
                                                                     TmpUser.OauthToken, TmpUser.OauthTokenSecret)
                          };


            _request = new RestRequest(CloudPtUrls.CloudPtGetSearch, Method.GET)
                           {
                               OnBeforeDeserialization = resp => { resp.ContentType = "application/json"; }
                           };


            _request.AddParameter("file_limit", true, ParameterType.UrlSegment);
            _request.AddParameter("include_deleted", false, ParameterType.UrlSegment);
            _request.AddParameter("query,", value, ParameterType.UrlSegment);

            _client.Timeout = 120000;
            _request.RequestFormat = DataFormat.Json;
            _client.ExecuteAsync(_request, clientResponse =>
            {
                if (clientResponse.ResponseStatus == ResponseStatus.Completed)
                {
                    //SearchvalidationHandler(clientResponse.Content);
                }
                if ((clientResponse.ResponseStatus == ResponseStatus.None) || (clientResponse.ResponseStatus == ResponseStatus.Error))
                {

                } ErrorHandler(clientResponse.ErrorException.Message);
            });
        }

        //private void SearchvalidationHandler(string value)
        //{
        //    try
        //    {
        //        using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(value)))
        //        {
        //            var ser = new DataContractJsonSerializer(typeof(InformacaoPastas));
        //            var tmp = (List<InformacaoPastas>)ser.ReadObject(ms);

        //            if (TmpDadosPastas == null)
        //            {
        //                TmpDadosPastas = new BindableCollection<InformacaoPastas>(tmp);
        //            }
        //            else
        //            {
        //                PreencheDadosPasta(tmp);
        //            }
        //            EventAggregationProvider.Aggregator.Publish(new EventoUtilizador(TipoEventoUtilizador.ConteudoUserOk));
        //        }
        //    }
        //    catch (Exception e)
        //    {

        //        EventAggregationProvider.Aggregator.Publish(e.InnerException == null
        //                                                        ? new AppMessage(AppMessageType.Erro, e.Message)
        //                                                        : new AppMessage(AppMessageType.Erro,
        //                                                                         e.InnerException + "\n" +
        //                                                                         e.Message));
        //    }
        //}


        #endregion
        #region Revs
        #endregion
        #region RestoreFile
        #endregion
        #region DevolveMedia
        #endregion

        #region GetSetFiles
        #region GetFile
        #endregion
        #region SetFile
        #endregion
        #endregion

        #region DevolveDelta
        #endregion

        #region CopyFile
        #endregion

        #region CopyReferencia
        #endregion

        #region Delete
        #endregion

        #region MoveFile
        #endregion

        #region CreateFolder
        #endregion

        #region UndeleteTree
        #endregion

        #region InfoUser
        #endregion
        #endregion

        #region Metodos Genericos
        #region Networking
        /// <summary>
        /// metodos para lidar com o acesso a rede
        /// </summary>
        /// <returns></returns>
        public bool IsNetworkEnabled()
        {

            if (PhoneNetWorkEnabled())
            {
                if ((IsWifinNetworkEnabled()) || (IsCellularDataEnabled()))
                {
                    return true;
                }
            }
            return false;
        }
        /// <summary>
        /// metodo para verificar se tem acesso a net
        /// </summary>
        /// <returns></returns>
        private static bool PhoneNetWorkEnabled()
        {
            return DeviceNetworkInformation.IsNetworkAvailable;
        }
        /// <summary>
        /// metodo para detectar se existe acesso a wifi
        /// </summary>
        /// <returns></returns>
        private static bool IsWifinNetworkEnabled()
        {
            return DeviceNetworkInformation.IsWiFiEnabled;
        }
        /// <summary>
        /// metodo para detectar se existe acesso a 3g/4g
        /// </summary>
        /// <returns></returns>
        private static bool IsCellularDataEnabled()
        {
            return DeviceNetworkInformation.IsCellularDataEnabled &&
                   DeviceNetworkInformation.IsCellularDataRoamingEnabled;
        }
        #endregion
        #region DB
        #region VerificaFicheiro
        
        #endregion

        #region InicializaBaseDados
        /// <summary>
        /// metodo para inicializar a base de dados
        /// </summary>
        public void InicializaBasedados()
        {
            
        }
        #endregion

        

        

        #endregion

        

        #region FilesFoldersHandling
        #region PastaHandling
        #region CreateFolder
        /// <summary>
        /// metodo para criar a pasta
        /// </summary>
        /// <param name="valueNameDir"></param>
        public void CreateFolder(string valueNameDir)
        {
            try
            {
                using (TmpIsolatedStrage = IsolatedStorageFile.GetUserStoreForApplication())
                {
                    if ((!string.IsNullOrEmpty(valueNameDir)) && (!TmpIsolatedStrage.DirectoryExists(valueNameDir)))
                    {
                        TmpIsolatedStrage.CreateDirectory(valueNameDir);
                    }
                }

            }
            catch (Exception ex)
            {

                EventAggregationProvider.Aggregator.Publish(new EventosIO(TipoEventoIo.PastaCreateError, ex.Message));
            }
        }
        #endregion

        #region DeleteFolder
        /// <summary>
        /// metodo para eliminar pasta
        /// </summary>
        /// <param name="value"></param>
        public void DeleteFolder(string value)
        {
            try
            {
                using (TmpIsolatedStrage = IsolatedStorageFile.GetUserStoreForApplication())
                {
                    var spath = Path.Combine(value, "*.*");
                    var folderContent = TmpIsolatedStrage.GetFileNames(spath);
                    if (folderContent.Length > 0)
                    {
                        EventAggregationProvider.Aggregator.Publish(new EventosIO(TipoEventoIo.PastaDeleteError, "A pasta: " + value + " nao está vazia,elimine os ficheiros desta pasta primeiro"));
                    }
                    else
                    {
                        if ((!string.IsNullOrEmpty(value)) && (!TmpIsolatedStrage.DirectoryExists(value)))
                        {
                            TmpIsolatedStrage.DeleteDirectory(value);
                        }
                    }
                }
            }
            catch (Exception ex)
            {

                EventAggregationProvider.Aggregator.Publish(new EventosIO(TipoEventoIo.PastaDeleteError, "Ocorreu o seguinte erro ao eliminar a pasta: " + value + " " + ex.Message));
            }
        }
        #endregion

        #region CopyFolder
        /// <summary>
        /// metodo para copiar a pasta
        /// </summary>
        /// <param name="valueInicial"></param>
        /// <param name="valueDestino"></param>
        public void CopyFolder(string valueInicial, string valueDestino)
        {
            try
            {

            }
            catch (Exception ex)
            {

                EventAggregationProvider.Aggregator.Publish(new EventosIO(TipoEventoIo.PastaCopyError, "Erro ao copiar a pasta: " + valueInicial + " para " + valueDestino + " foi gerado o seguinte erro:" + ex.Message));
            }
        }
        #endregion

        #region MoveFolder
        /// <summary>
        /// mover pasta
        /// </summary>
        /// <param name="valueInicial"></param>
        /// <param name="valueDestino"></param>
        public void MovePasta(string valueInicial, string valueDestino)
        {
            try
            {
                using (TmpIsolatedStrage = IsolatedStorageFile.GetUserStoreForApplication())
                {
                    TmpIsolatedStrage.MoveDirectory(valueInicial, valueDestino);
                }
            }
            catch (Exception ex)
            {

                EventAggregationProvider.Aggregator.Publish(new EventosIO(TipoEventoIo.PastaMoveError, "Ocorreu o seguinte erro ao mover a pasta: " + valueInicial + " " + ex.Message));
            }
            EventAggregationProvider.Aggregator.Publish(new EventosIO(TipoEventoIo.PastaMoveOk, "a pasta " + valueInicial + " foi movida com sucesso para: " + valueDestino));
        }
        #endregion
        #endregion
        #region FileHandling
        #region CreateFile
        /// <summary>
        /// metodo para criar o ficheiro
        /// </summary>
        /// <param name="valuePasta"></param>
        /// <param name="valueFicheiro"></param>
        public void CriaFicheiro(string valuePasta, string valueFicheiro)
        {
            try
            {
                var pathFicheiro = Path.Combine(valuePasta, valueFicheiro);
                using (TmpIsolatedStrage = IsolatedStorageFile.GetUserStoreForApplication())
                {
                    StreamWriter tmpstream;
                    if (!TmpIsolatedStrage.DirectoryExists(valuePasta))
                    {
                        TmpIsolatedStrage.CreateDirectory(valuePasta);

                        tmpstream =
                            new StreamWriter(new IsolatedStorageFileStream(pathFicheiro,
                                                                           FileMode.CreateNew, TmpIsolatedStrage));

                        tmpstream.Close();
                        tmpstream.Dispose();
                    }
                    else
                    {
                        tmpstream = new StreamWriter(new IsolatedStorageFileStream(pathFicheiro,
                                                                           FileMode.CreateNew, TmpIsolatedStrage));
                        tmpstream.Close();
                        tmpstream.Dispose();
                        
                    }
                }
            }
            catch (Exception ex)
            {

                EventAggregationProvider.Aggregator.Publish(new EventosIO(TipoEventoIo.FicheiroCreateError, "Ocorreu o seguinte erro ao criar o ficheiro" + valueFicheiro +
                    " " + ex.Message));
            }
            EventAggregationProvider.Aggregator.Publish(new EventosIO(TipoEventoIo.FicheiroCreateOk, "o ficheiro: " + valueFicheiro + " foi criado com sucesso"));
        }
        #endregion

        #region DeleteFile
        /// <summary>
        /// elimina ficheiro
        /// </summary>
        /// <param name="valuePasta"></param>
        /// <param name="valueFicheiro"></param>
        public void EliminaFicheiro(string valuePasta, string valueFicheiro)
        {
            try
            {
                using (TmpIsolatedStrage = IsolatedStorageFile.GetUserStoreForApplication())
                {
                    if (!TmpIsolatedStrage.DirectoryExists(valuePasta))
                    {
                        EventAggregationProvider.Aggregator.Publish(new EventosIO(TipoEventoIo.FicheirosDeleteError, "Ocorreu o seguinte erro ao eliminar o ficheiro: " +
                             valueFicheiro + " a pasta " + valuePasta + " nao existe"));
                    }
                    else
                    {
                        if ((!string.IsNullOrEmpty(valuePasta)) && (!string.IsNullOrEmpty(valueFicheiro)))
                        {
                            var path = Path.Combine(valuePasta, valueFicheiro);
                            TmpIsolatedStrage.DeleteFile(path);
                        }
                    }
                }
            }
            catch (Exception ex)
            {

                EventAggregationProvider.Aggregator.Publish(new EventosIO(TipoEventoIo.FicheirosDeleteError, "Ocorreu o seguinte erro ao eliminar o ficheiro: " +
                    valueFicheiro + " " + ex.Message));
            }
        }
        #endregion

        #region CopyFile
        /// <summary>
        /// copia o ficheiro
        /// </summary>
        /// <param name="valueOldLocation"></param>
        /// <param name="valueNewLocation"></param>
        /// <param name="valueFile"></param>
        public void CopyFile(string valueOldLocation, string valueNewLocation, string valueFile)
        {
            try
            {
                using (TmpIsolatedStrage = IsolatedStorageFile.GetUserStoreForApplication())
                {

                    if ((string.IsNullOrEmpty(valueOldLocation)) || (string.IsNullOrEmpty(valueNewLocation)) ||
                        (string.IsNullOrEmpty(valueFile)))
                    {
                        EventAggregationProvider.Aggregator.Publish(new EventosIO(TipoEventoIo.FicheiroCopyError,
                                                                                  "Ocorreu o seguinte erro ao copiar o ficheiro um dos valores nao pode ser vazio"));
                    }
                    else
                    {
                        var pathficheiroOriginal = Path.Combine(valueOldLocation, valueFile);
                        var pathficheiroDestino = Path.Combine(valueNewLocation, valueFile);
                        if (TmpIsolatedStrage.DirectoryExists(valueNewLocation))
                        {
                            TmpIsolatedStrage.CopyFile(pathficheiroOriginal, pathficheiroDestino);
                        }
                        else
                        {
                            TmpIsolatedStrage.CreateDirectory(valueNewLocation);
                            TmpIsolatedStrage.CopyFile(pathficheiroOriginal, pathficheiroDestino);
                        }
                    }
                }
            }
            catch (Exception ex)
            {

                EventAggregationProvider.Aggregator.Publish(new EventosIO(TipoEventoIo.FicheiroCopyError, "Ocorreu o seguinte erro ao copiar o ficheiro:" + valueOldLocation +
                    " " + ex.Message));
            }
        }
        #endregion

        #region MoveFile
        public void MoveFicheiro(string valueOldLocation, string valueNewLocation, string valueFile)
        {
            try
            {
                using (TmpIsolatedStrage = IsolatedStorageFile.GetUserStoreForApplication())
                {

                    if ((string.IsNullOrEmpty(valueOldLocation)) || (string.IsNullOrEmpty(valueNewLocation)) ||
                        (string.IsNullOrEmpty(valueFile)))
                    {
                        EventAggregationProvider.Aggregator.Publish(new EventosIO(TipoEventoIo.FicheiroMoveError,
                                                                                  "Ocorreu o seguinte erro ao mover o ficheiro um dos valores nao pode ser vazio"));
                    }
                    else
                    {
                        var pathficheiroOriginal = Path.Combine(valueOldLocation, valueFile);
                        var pathficheiroDestino = Path.Combine(valueNewLocation, valueFile);
                        if (TmpIsolatedStrage.DirectoryExists(valueNewLocation))
                        {
                            TmpIsolatedStrage.MoveFile(pathficheiroOriginal, pathficheiroDestino);
                        }
                        else
                        {
                            TmpIsolatedStrage.CreateDirectory(valueNewLocation);
                            TmpIsolatedStrage.MoveFile(pathficheiroOriginal, pathficheiroDestino);
                        }
                    }
                }
            }
            catch (Exception ex)
            {

                EventAggregationProvider.Aggregator.Publish(new EventosIO(TipoEventoIo.FicheiroMoveError, "Ocorreu o seguinte erro ao mover o ficheiro: " +
                    valueFile + " para a pasta: " + valueNewLocation + " " + ex.Message));
            }
        }
        #endregion
        #endregion
        #endregion
        #endregion

       
    }
}
